/**
 * 
 * 广州锐鹏计算机科技有限公司（www.ruipengkj.com）
 * 
 * 
 * Copyright (c) 2011-2012 RUIPENGKJ.Co.Ltd. All rights reserved.
 * 
 * */
package com.ruipengkj;

import java.awt.Component;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

import com.dianlian.pss.inter.Connection;
import com.dianlian.pss.inter.OperateException;
import com.dianlian.util.card.CardUtil;
import com.dianlian.util.card.DefaultCardListener;
import com.ruipengkj.bean.TBillDetail;
import com.ruipengkj.bean.TBillDetailDes;
import com.ruipengkj.bean.TCommodity;
import com.ruipengkj.bean.TEmployee;
import com.ruipengkj.bean.TMoneyInOut;
import com.ruipengkj.bean.TRole;
import com.ruipengkj.bean.TShop;
import com.ruipengkj.bean.TStock;
import com.ruipengkj.bean.TStockInOut;
import com.ruipengkj.bean.TStockInOutDetail;
import com.ruipengkj.bean.TStore;
import com.ruipengkj.commons.BuildSpringApplication;
import com.ruipengkj.commons.util.UUID;
import com.ruipengkj.commons.util.Util;
import com.ruipengkj.commons.util.jna.QueryMember;
import com.ruipengkj.init.InitContext;
import com.ruipengkj.service.TBillDetailDesService;
import com.ruipengkj.service.TBillDetailService;
import com.ruipengkj.service.TCommodityService;
import com.ruipengkj.service.TMoneyInOutService;
import com.ruipengkj.service.TStockInOutDetailService;
import com.ruipengkj.service.TStockInOutService;
import com.ruipengkj.service.TStockService;
import com.ruipengkj.view.orderView.dish.cooking.CommodityExeAttr;
import com.ruipengkj.view.orderView.dish.cooking.CommodityExeAttrOption;
import com.ruipengkj.view.orderView.dish.cooking.CommodityExeAttrs;


/**
 * 说明： 应用上下文类
 * 
 * @Author：李智深
 * @Date：2012-03-14
 */
public class ApplicationContext {
	public static String lockPassword;// 锁屏密码

	public static TEmployee EMPLOYEE=null;//软件登陆员工对象
	public static String EMPLOYEE_SN=null;//登陆软件员工号
	public static TRole ROLE=null;//当前软件操作角色
	public static List<Byte> TRIGHT_LIST=new ArrayList<Byte>();//权限列表
	public static String OPERATOR_NAME=null;//操作员名称
	public static String OPERATOR_ID=null;//操作员ID
	public static String OPERATOR_ROLE_NAME=null;//权限名称
	public static TShop SHOP_INFO=null;//商店信息
	public static double CHANGE_MANEY=0;//找零
	public static double CHANGE_CASH=0;//现金
	public static String WORKSHIFT_ID=null;//交班ID(订单批次号)
	public static Connection conn = null;//
	//public static CardUtil CardUtilThread=new CardUtil();//
//	public static CardUtil2 CardUtilThread2=new CardUtil2();//
	public static Set<String> PICDOWMCACHE_SET = new HashSet<String>();
	public static Connection getSynConnection() throws OperateException
	{
		Properties ps = InitContext.getinstance().LoadDataBaseData();
		String clientID=ps.getProperty("pool.clientID");
		if(!(clientID!="" && clientID!=null)){
			clientID=UUID.GenUUID15();
			ps.setProperty("pool.clientID", clientID);
			try {
				FileOutputStream outputFile = new FileOutputStream("jdbc.properties");
				ps.store(outputFile , "");
				outputFile.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(conn == null)
		{
            if(ApplicationContext.SHOP_INFO == null)
            {
                throw new OperateException("没有设置与店联的同步信息，请在\"基础数据管理->商店管理\"中填写");
            }
			conn = new Connection(ApplicationContext.SHOP_INFO.getShopID(), clientID, ApplicationContext.EMPLOYEE.getName(), ApplicationContext.EMPLOYEE.getPassword());
		}
		return conn;
	}
    public static QueryMember query_member = null;

    public enum CardType {CT_None, CT_All, CT_Unknown, CT_DLInited, CT_DLSended};
	private static Component cardNum = null;
    private static CardType listenCardType = CardType.CT_None;
    private static CardType currCardType = CardType.CT_Unknown;
    public static void listenCard(Component _cardNum, CardType _cardType)
    {
        cardNum = _cardNum;
        listenCardType = _cardType;
    }
	public static CardUtil CardUtilThread=new CardUtil(new DefaultCardListener() {
        @Override
        public void onCardWriterInit(boolean _success) {
        }

        @Override
        public void onSearchUnknownCard(int _cardSer) {
            currCardType = CardType.CT_Unknown;
            if(listenCardType == CardType.CT_None)
            {
                return;
            }
            InvalidCardType(currCardType);
        }

        @Override
        public void onSeachDLUnSendCard(int _cardSer, String _cardNum) {
            currCardType = CardType.CT_DLInited;
            if(listenCardType == CardType.CT_None)
            {
                return;
            }
            else if(listenCardType == CardType.CT_All || listenCardType == CardType.CT_DLInited)
            {
                onGetCardNum(_cardNum);
                CardUtilThread.beep();
            }
            else
            {
                InvalidCardType(currCardType);
            }
        }

        @Override
        public void onSearchDLCard(int _cardSer, String _cardNum) {
            currCardType = CardType.CT_DLSended;
            if(listenCardType == CardType.CT_None)
            {
                return;
            }
            else if(listenCardType == CardType.CT_All || listenCardType == CardType.CT_DLSended)
            {
                onGetCardNum(_cardNum);
                CardUtilThread.beep();
            }
            else
            {
                InvalidCardType(currCardType);
            }
        }

        @Override
        public void onReadDLCard(String _cardNum, String _userID, String _mobile, String _name) {
            onGetCardNum(_cardNum);
        }

        private void onGetCardNum(String _cardNum)
        {
            final String readCardNum = _cardNum;
            if (cardNum != null) {
                SwingUtilities.invokeLater(new Runnable()
                {
                    @Override
                    public void run() {
                        if (cardNum instanceof JTextField) {
                    		((JTextField)cardNum).setText(readCardNum);
                        } else if (cardNum instanceof JLabel) {
                    		((JLabel)cardNum).setText(readCardNum);
                    	}
                    	if (query_member != null) {
                    		query_member.queryMember();
                    	}
                    }
                });
            }
        }

        private void InvalidCardType(CardType _cardType)
        {
            final CardType errorCardType = _cardType;
            SwingUtilities.invokeLater(new Runnable()
            {
                @Override
                public void run() {
                    if(errorCardType == CardType.CT_Unknown)
                    {
                        JOptionPane.showMessageDialog(null, "未初始化卡或者非店联卡");
                    }
                    else if(errorCardType == CardType.CT_DLInited)
                    {
                        JOptionPane.showMessageDialog(null, "未发出的卡");
                    }
                    else if(errorCardType == CardType.CT_DLSended)
                    {
                        JOptionPane.showMessageDialog(null, "已发出的卡");
                    }
                }
            });
        }
	});//
//	public static CardUtil2 CardUtilThread2=new CardUtil2();//
	
	//商品sql語句---銷售
	public static String commodity_sql_sales = "select o.commodityID, o.price, o.name, o.discountPrice, "+
		 	 "o.barcode, o.batchPrice, o.unit, o.avgPrice, o.disCount from ruipeng_tb_TCommodity o "+
		 	 "left join ruipeng_tb_TProductCatalog p on o.TProductCatalogid = p.catalogID "+
		 	 "where (o.intoSales='仅销售' or o.intoSales='进货销售' or (o.intoSales is null and "+
		 	 "(p.intoSales is null or p.intoSales!='仅进货')))";
	//進貨
	public static String commodity_sql_buy = "select o.commodityID, o.price, o.name, o.discountPrice, "+
		 	 "o.barcode, o.batchPrice, o.unit, o.avgPrice, sum(s.num) from ruipeng_tb_TCommodity o "+
			 "left join  ruipeng_tb_TStock s on s.commodityID = o.commodityID "+
		 	 "left join ruipeng_tb_TProductCatalog p on o.TProductCatalogid = p.catalogID "+
		 	 "where (o.intoSales='仅进货' or o.intoSales='进货销售' or (o.intoSales is null and "+
		 	 "(p.intoSales is null or p.intoSales!='仅销售')))";
	//采购退货
	public static String commodity_sql_buy_reutrn = "select o.commodityID, o.price, o.name, o.discountPrice, "+
		 	 "o.barcode, o.batchPrice, o.unit, o.avgPrice from ruipeng_tb_tstock s, ruipeng_tb_tstore store, ruipeng_tb_TCommodity o "+
		 	 "left join ruipeng_tb_TProductCatalog p on o.TProductCatalogid = p.catalogID "+
		 	 "where (o.intoSales='仅进货' or o.intoSales='进货销售' or (o.intoSales is null and "+
		 	 "(p.intoSales is null or p.intoSales!='仅销售'))) and o.CommodityID=s.CommodityID and store.StoreID=s.StoreID";
	
	public static String TIME_NAME(String hourStr) {
		int hour = Integer.parseInt(hourStr);
		if (hour >= 7 && hour < 11) {
			return "上午好!";
		} else if (hour >= 11 &&hour < 15) {
			return "中午好!";
		} else if (hour >= 15 && hour < 18) {
			return "下午好!";
		} else {
			return "晚上好！";
		}
	}
	
	public static String[] MEMBER_CHARGE_TYPE = new String[]{"1、充值xx送xx", "2、放大率xx"}; 
//图片先关对象类型
	public static byte TITEMPICTYPE_1=1;//商品
	public static byte TITEMPICTYPE_2=2;
	public static byte TITEMPICTYPE_3=3;
	
	//交班状态  1为未交班 2为已交班
	public static byte WORKSHIFT_STATUS1=1;
	public static byte WORKSHIFT_STATUS2=2;
	
	//会员级别定义类型（1为系统级别，2为自定义级别）
	public static byte TYPE_SYSTEM=1;
	public static byte TYPE_CUSTOM=2;
	
	//退款单状态
	public static byte ORDERREFUND_STATUS1=1;
	public static byte ORDERREFUND_STATUS2=2;
	public static byte ORDERREFUND_STATUS3=3;
	public static Map<Byte,String> ORDERREFUND_STATUS_MAP(){
		Map<Byte,String> map = new LinkedHashMap<Byte,String>();
		map.put((byte)1, "申请中");
		map.put((byte)2, "同意退款");
		map.put((byte)3, "拒绝退款");
		
		return map;
	}
	
	//是否有折扣
	public static boolean ISDISCOUNT_YES=true;
	public static boolean ISDISCOUNT_NO=false;
	public static Map<Boolean,String> MEMBERLEVEL_ISDISCOUNT_MAP(){
		Map<Boolean,String> map =new LinkedHashMap<Boolean,String>();
		map.put(true, "是");
		map.put(false, "否");
		
		return map;
	}
	
	//是否开启客服
	public static boolean ISCLIENTSERVICE_YES=true;
	public static boolean ISCLIENTSERVICE_NO=false;
	public static Map<Boolean,String> DATEEMPLOYEE_ISCLIENTSERVICE_MAP(){
		Map<
	Boolean,String> map = new LinkedHashMap<Boolean,String>();
		map.put(true, "是");
		map.put(false, "否");
		
		return map;
	}
	
	//阀值类型
	public static byte WALUETYPE_TYPE1=1;
	public static byte WALUETYPE_TYPE2=2;
	public static byte WALUETYPE_TYPE3=3;
	public static Map<Byte,String> MEMBERLEVEL_WALUETYPE_MAP(){
		Map<Byte,String> map =new LinkedHashMap<Byte,String>();
		map.put((byte)1,"消费积分");
		map.put((byte)2,"充值积分");
		map.put((byte)3,"");
		return map;
	}
	//报损类型1为商品报损(此时使用人为报损人)	2为员工领用（此时使用人为使用员工）3为其它原因出库（此时使用人字段未使用）
	public static byte OUTBILL_REASONTYPE1=1;
	public static byte OUTBILL_REASONTYPE2=2;
	public static byte OUTBILL_REASONTYPE3=3;
	public static Map<Byte,String> OUTBILL_REASONTYPE_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)100, "请选择");
		map.put((byte)1, "商品报损");
		map.put((byte)2, "员工领用");
		map.put((byte)3, "其它原因");
		return map;
	}
	
	//商品类型
	public static byte COMMODITY_TYPE1=1;
	public static byte COMMODITY_TYPE2=2;
	public static Map<Byte,String> COMMODITY_TYPE_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "正常商品");
		map.put((byte)2, "套餐");
		return map;
	}
	//商品状态
	public static byte COMMODITY_STATUS_YES=1;
	public static byte COMMODITY_STATUS_NO=2;
	public static Map<Byte,String> COMMODITY_STATUS_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "已发布");
		map.put((byte)2, "未发布");
		return map;
	}
	
	//有效期1为天 2为月 3为年
	public static byte VALIDITY_1=1;
	public static Map<Byte,String> VALIDITY_MAP(){
		Map<Byte,String> map=new HashMap<Byte,String>();
		map.put((byte)1, "天");
		map.put((byte)2, "月");
		map.put((byte)3, "年");
		return map;
	}
	
	// 付款方式
	public static Map<Byte,String> PLAY_MATHOD_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)7, "现金消费");
		map.put((byte)8, "会员卡消费");
//		map.put((byte)9, "刷卡消费");
		return map;
	}
	public static String PLAY_MATHOD_TEXT7="现金消费";

	//支付状态
	public static byte PLAY_STATUS_NO = 1;//未支付
	public static byte PLAY_STATUS_YES = 2;//已支付 
	public static String PLAY_STATUS_NO_TEXT = "未支付";//未支付
	public static String PLAY_STATUS_YES_TEXT = "已支付";//已支付 
	public static Map<Byte,String> PLAY_STATUS_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "未支付");
		map.put((byte)2, "已支付 ");
		return map;
	}
	
	//支付状态
	public static byte Comment_STATUS_SC = 1;//商店评论
	public static byte Comment_STATUS_CC = 2;//商品评论
	public static byte Comment_STATUS_SA = 11;//商店咨询
	public static byte Comment_STATUS_CA = 21;//商品咨询
	public static String Comment_STATUS_SC_TEXT = "商店评论";
	public static String Comment_STATUS_CC_TEXT = "商品评论";
	public static String Comment_STATUS_CA_TEXT = "商店咨询";
	public static String Comment_STATUS_SA_TEXT = "商品咨询";
	public static Map<Byte,String> Comment_STATUS_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "商店评论");
		map.put((byte)2, "商品评论");
		map.put((byte)11, "商店咨询");
		map.put((byte)21, "商品咨询");
		return map;
	}
	
	//订单类型
	public static byte ORDER_TYPE1=1;//零售
	public static byte ORDER_TYPE2=2;//批发
	
	//定单类型
	public static byte ORDERTYPE1=1;//1为个人定单
	public static byte ORDERTYPE21=21;//21为企业定单（个人支付）
	public static byte ORDERTYPE22=22;//22为企业定单（企业支付）
	public static byte ORDERTYPE3=3;//3为楼宇定餐定单，当类型为3时，群组编号为定单生成时的位置编号

	  
	
	//配送方式
	public static byte ORDER_SENDWAY_MODT1=1;//送货上门 
	public static byte ORDER_SENDWAY_MODT2=2;//物流
	public static byte ORDER_SENDWAY_MODT3=3;//店内取货
	public static String ORDER_SENDWAY_MODT1_TEXT="送货上门";//送货上门 
	public static String ORDER_SENDWAY_MODT2_TEXT="物流";//物流
	public static String ORDER_SENDWAY_MODT3_TEXT="店内取货";//店内取货
	public static Map<Byte,String> ORDER_SENDWAY_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "送货上门 ");
		map.put((byte)2, "物流");
		map.put((byte)3, "店内取货");
		return map;
	}
	
	//结束方式
	public static byte ORDER_ENDWAY_MODT0=0;//未设置
	public static byte ORDER_ENDWAY_MODT1=1;//成功完成
	public static byte ORDER_ENDWAY_MODT2=2;//已合并
	public static byte ORDER_ENDWAY_MODT3=3;//已取消
	public static byte ORDER_ENDWAY_MODT4=4;//卖家已取消
	public static byte ORDER_ENDWAY_MODT5=5;//卖家无法送抵（比如说买家不要了）
	public static Map<Byte,String> ORDER_ENDWAY_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)0, "未设置");
		map.put((byte)1, "成功完成");
		map.put((byte)2, "已合并");
		map.put((byte)3, "已取消");
		map.put((byte)4, "卖家已取消");
		map.put((byte)5, "卖家无法送抵（比如说买家不要了）");
		return map;
	}
	//订单来源 1为店内订单2为网络订单 3电话订单
	public static byte ORDER_SOURCE1=1;
	public static byte ORDER_SOURCE2=2;
	public static byte ORDER_SOURCE3=3;
	public static Map<Byte,String> ORDER_SOURCE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)100, "请选择");
		map.put((byte)1, "店内订单");
		map.put((byte)2, "网络订单");
		map.put((byte)3, "电话订单");
		return map;
	}
	
	//票据类型
	public static byte BILLTYPE1=1;//收据
	public static byte BILLTYPE2=2;//发票
	
	//评价状态
	public static byte COMMENNTSTATUS1=00;//商店未评价，商品未评价
	public static byte COMMENNTSTATUS2=01;//商店未评价，商品已评价
	public static byte COMMENNTSTATUS3=10;//商店已评价，商品未评价
	public static byte COMMENNTSTATUS4=11;//商店已评价，商品已评价
	
	//订单状态  该字节的10位为撤消标记 0为没有撤消，1为正在撤消
	public static byte ORDER_STATUS01=01;//01为开始创建的定单
	public static byte ORDER_STATUS02=02;//02为确认定单
	public static byte ORDER_STATUS03=03;//03为已确定支付方式
	public static byte ORDER_STATUS04=04;//04为定单已分配（确认货源）
	public static byte ORDER_STATUS05=05;//05为定单正在执行调度
	public static byte ORDER_STATUS06=06;//06为定单已发货
	public static byte ORDER_STATUS07=07;//07为定单已完成
	public static byte ORDER_STATUS11=11;//11为开始创建的定单
	public static byte ORDER_STATUS12=12;//12为确认定单
	public static byte ORDER_STATUS13=13;//13为已确定支付方式
	public static byte ORDER_STATUS14=14;//14为定单已分配（确认货源）
	public static byte ORDER_STATUS15=15;//15为定单正在执行调度
	public static byte ORDER_STATUS16=16;//16为定单已发货
	public static byte ORDER_STATUS17=17;//17为定单已完成
	public static String ORDER_STATUS01_TEXT="开始创建的定单";//01为开始创建的定单
	public static String ORDER_STATUS02_TEXT="确认定单";//02为确认定单
	public static String ORDER_STATUS03_TEXT="确定支付方式";//03为已确定支付方式
	public static String ORDER_STATUS04_TEXT="已分配";//04为定单已分配（确认货源）
	public static String ORDER_STATUS05_TEXT="正在执行调度";//05为定单正在执行调度
	public static String ORDER_STATUS06_TEXT="已发货";//06为定单已发货
	public static String ORDER_STATUS07_TEXT="已完成";//07为定单已完成
	public static String ORDER_STATUS11_TEXT="开始创建的定单";//11为开始创建的定单
	public static String ORDER_STATUS12_TEXT="确认定单";//12为确认定单
	public static String ORDER_STATUS13_TEXT="已确定支付方式";//13为已确定支付方式
	public static String ORDER_STATUS14_TEXT="已分配";//14为定单已分配（确认货源）
	public static String ORDER_STATUS15_TEXT="正在执行调度";//15为定单正在执行调度
	public static String ORDER_STATUS16_TEXT="已发货";//16为定单已发货
	public static String ORDER_STATUS17_TEXT="已完成";//17为定单已完成
	public static Map<Byte,String> ORDER_STATUS_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)100, "请选择");
		map.put((byte)01, "开始创建的定单");//01为开始创建的定单
		map.put((byte)02, "确认定单");//02为确认定单
		map.put((byte)03, "确定支付方式");//03为已确定支付方式
		map.put((byte)04, "已分配");//04为定单已分配（确认货源）
		map.put((byte)05, "正在执行调度");//05为定单正在执行调度
		map.put((byte)06, "已发货");//06为定单已发货
		map.put((byte)07, "已完成");//07为定单已完成
		map.put((byte)11, "开始创建的定单");//11为开始创建的定单
		map.put((byte)12, "确认定单");//12为确认定单
		map.put((byte)13, "已确定支付方式");//13为已确定支付方式
		map.put((byte)14, "已分配");//14为定单已分配（确认货源）
		map.put((byte)15, "正在执行调度");//15为定单正在执行调度
		map.put((byte)16, "已发货");//16为定单已发货
		map.put((byte)17, "已完成");//17为定单已完成
		return map;
	}
	
	//桌子状态
	public static byte DESK_STATUS1=1;//1为空闲 
	public static byte DESK_STATUS2=2;//2为正在消费中
	public static byte DESK_STATUS3=3;//3为正在预订中
//	public static String DESK_STATUS_TEXT1="空闲";//1为空闲 
//	public static String DESK_STATUS_TEXT2="消费中";//2为正在消费中
//	public static String DESK_STATUS_TEXT3="";//3为正在预订中
	
	public static Map<Boolean,String> DESK_BOOK_MAP(){
		Map<Boolean,String> map=new LinkedHashMap<Boolean,String>();
		map.put((Boolean)true, "可预订");//01为开始创建的定单
		map.put((Boolean)false, "不可预订");//01为开始创建的定单
		return map;
	}
	
	//在线预订当状态
	public static byte ORDER_STATUS1=1;//1在线预订 预订
	public static byte ORDER_STATUS2=2;//2完成
	public static String ORDER_STATUS1_TEXT="预订";//1在线预订 预订
	public static String ORDER_STATUS2_TEXT="完成";//2完成
	
	// 单据类型
	public static byte BILL_BILLTYPE1=1;//1为采购单 
	public static byte BILL_BILLTYPE2=2;//2为采购退货单
	public static byte BILL_BILLTYPE3=3;//3为销售定单
	public static byte BILL_BILLTYPE4=4;//4为销售退货单
	public static byte BILL_BILLTYPE5=5;//5为员工领用单
	public static byte BILL_BILLTYPE6=6;//6为报损单
	public static byte BILL_BILLTYPE7=7;//7为仓库调拨单
	public static byte BILL_BILLTYPE8=8;//8其他原因出库单
	public static byte BILL_BILLTYPE9=9;//8会员充值
	public static Map<Byte,String>  MONEYINOUT_BILL_TYPE_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
			map.put((byte)1, "采购进货出款");
			map.put((byte)2, "采购退货收款");
			map.put((byte)3, "销售收款");
			map.put((byte)4, "销售退货出款");
			map.put((byte)5, "员工领用出款");
			map.put((byte)6, "报损出款");
			map.put((byte)7, "");
			map.put((byte)8, "其他原因出款");
			map.put((byte)9, "会员充值收款");
			return map;
		}
	
	//库存入/出类型TINYINT 1为入库单 2为出库单
	public static byte STOCK_TYPE_IN=1;
	public static byte STOCK_TYPE_OUT=2;
	public static Map<Byte,String> STOCK_TYPE_IN_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "入库");
		map.put((byte)2, "出库");
		return map;
	}

	//计量单位
	public static Map<Byte,String> UNIT_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "盒");
		map.put((byte)2, "件");
		map.put((byte)3, "打");
		return map;
	}
	
	
	//打折类型 
	public static Map<Byte,String> DISCOUNTTYPE_TYPE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "不打折");
		map.put((byte)2, "折扣");
		map.put((byte)3, "降价");
		return map;
	}
	
	//性别
	public static Map<Byte,String> SEX_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "男");
		map.put((byte)2, "女");
		return map;
	}
	
	//工作性质  TINYINT1为全职 2为兼职
	public static Map<Byte,String> JOBTYPE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "全职");
		map.put((byte)2, "兼职");
		return map;
	}
	//文化程度TINYINT 1为未知 2为小学 2为中学 3为高中 4为大学 5为硕士 6为博士
	public static Map<Byte,String> EDULEVEL_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "未知");
		map.put((byte)2, "小学");
		map.put((byte)3, "中学 ");
		map.put((byte)4, "高中");
		map.put((byte)5, "大学");
		map.put((byte)6, "硕士");
		map.put((byte)7, "博士");
		return map;
	}
	
	//工作年限  1为 1--5是相对应的工作年限，6为5年以上
	public static Map<Byte,String> WYLEVEL_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "1年");
		map.put((byte)2, "2年");
		map.put((byte)3, "3年");
		map.put((byte)4, "4年");
		map.put((byte)5, "5年");
		map.put((byte)6, "6年以上");
		return map;
	}
	
	//招聘管理 文化程度 TINYINT 10为中学 20为高中 30为中技 40为中专 50 为大专 60 为本科 70为硕士 80为博士
	public static Map<Byte,String> JOBEDULEVEL_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)0, "未知");
		map.put((byte)10, "小学");
		map.put((byte)20, "高中 ");
		map.put((byte)30, "中技");
		map.put((byte)40, "中专");
		map.put((byte)50, "大专");
		map.put((byte)60, "本科");
		map.put((byte)70, "硕士");
		map.put((byte)80, "博士");
		return map;
	}
	
	//薪资水平 薪资水平TINYINT 1为面议 2为1000-2000 3为2000-3000 4为3000-4000 5为4000-5000 6为5000-6000 7为6000以上
	public static Map<Byte,String> SALEVEL_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "面议");
		map.put((byte)2, "1000-2000 ");
		map.put((byte)3, "2000-3000");
		map.put((byte)4, "3000-4000");
		map.put((byte)5, "4000-5000");
		map.put((byte)6, "5000-6000");
		map.put((byte)7, "6000以上");
		return map;
	}
	
	//满就送 1 为优惠卷 2为送商品
	public static Map<Byte,String> GIFT_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "优惠卷");
		map.put((byte)2, "送商品");
		return map;
	}
	
	
	
	//商品主形象类型 TINYINT1为一张大图片 2为3D形象 3为几张图片组成的图片集
	public static byte MAINIMAGETYPE1=1;//1为一张大图片
	public static byte MAINIMAGETYPE2=2;//2为3D形象 
	public static byte MAINIMAGETYPE3=3;//3为几张图片组成的图片集
	public static String MAINIMAGETYPE1_TEXT="一张大图片";//1为一张大图片
	public static String MAINIMAGETYPE2_TEXT="3D形象";//2为3D形象 
	public static String MAINIMAGETYPE3_TEXT="几张图片组成的图片集";//3为几张图片组成的图片集
	
	
	//资金出入类型1为收款 2为出款
	public static byte MONEYINOUT_TYPE_IN=1;
	public static byte MONEYINOUT_TYPE_OUT=2;
	public static Map<Byte,String>  MONEYINOUT_TYPE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)100, "所有");
		map.put((byte)1, "入款");
		map.put((byte)2, "出款");
		return map;
	}
//	1为采购引起的出款
//	2为采购退货引起收款
//	3为销售引起的收款
//	4为销售退货引起的出款
//	5为充值收款
//	6为商品报损出款
//	7为物品领用出款
//	8为其他方式出库出款
//	资金出入原因类型1为采购引起的出款 2为采购退货引起收款3为销售引起的收款 4为销售退货引起的出款 5为充值收款 10为费用单 
	public static byte MONEYINOUT_SOURCE_TYPE1=1;
	public static byte MONEYINOUT_SOURCE_TYPE2=2;
	public static byte MONEYINOUT_SOURCE_TYPE3=3;
	public static byte MONEYINOUT_SOURCE_TYPE4=4;
	public static byte MONEYINOUT_SOURCE_TYPE5=5;
	public static byte MONEYINOUT_SOURCE_TYPE6=6;
	public static byte MONEYINOUT_SOURCE_TYPE7=7;
	public static byte MONEYINOUT_SOURCE_TYPE8=8;
	public static byte MONEYINOUT_SOURCE_TYPE10=10;
	public static Map<Byte,String>  MONEYINOUT_SOURCE_TYPE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "采购引起的出款");
		map.put((byte)2, "采购退货引起收款");
		map.put((byte)3, "销售引起的收款");
		map.put((byte)4, "销售退货引起的出款");
		map.put((byte)5, "充值收款");
		map.put((byte)6, "商品报损出款");
		map.put((byte)7, "物品领用出款");
		map.put((byte)8, "其他方式出库出款");
		map.put((byte)10, "费用单");
		return map;
	}
	
	public static int MONEYINOUT_SOURCE_TYPE(String str) {
		if (str.equals("采购引起的出款")) {
			return 1;
		} else if (str.equals("采购退货引起收款")) {
			return 2;
		} else if (str.equals("销售引起的收款")) {
			return 3;
		} else if (str.equals("销售退货引起的出款")) {
			return 4;
		} else if (str.equals("充值收款")) {
			return 5;
		} else if (str.equals("商品报损出款")) {
			return 6;
		} else if (str.equals("物品领用出款")) {
			return 7;
		} else if (str.equals("其他方式出库出款")) {
			return 8;
		}else {
			return 10;
		}
	}
	
	public static byte STOCK_IN_OUT_SOURCE_TYPE1=1;//"采购所引起的入库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE2=2;// "采购退货所引起的出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE3=3;// "销售定单所引起的出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE4=4;// "销售退货所引起的入库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE5=5;// "员工领用所引起的出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE6=6;// "报损所引起的出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE7=7;// "仓库调度所引起的出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE8=8;// "仓库调度所引起的入库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE9=9;// "生产材料领用出库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE10=10;// "生产成品入库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE100=100;// "未知原因的入库");
	public static byte STOCK_IN_OUT_SOURCE_TYPE101=101;// "未知原因的出库");
	//出入库原因单据类型
	public static Map<Byte,String> STOCK_IN_OUT_SOURCE_TYPE_MAP(){
	Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		//1为采购所引起的入库，原因单为采购单编号 2为采购退货所引起的出库，原因单为退货单
		//3为销售定单所引起的出库，原因单为销售定单 4为销售退货所引起的入库，原因单为销售退货单
		//5为员工领用所引起的出库，原因单为领用单 6为报损所引起的出库，原因单为报损单 
		//7为仓库调度所引起的出库，原因单为仓库调拨单 8为仓库调度所引起的入库，原因单为仓库调拨单 
		//9为生产材料领用出库 10为生产成品入库 100为未知原因的入库 101为未知原因的出库
		map.put((byte)1, "采购所引起的入库");
		map.put((byte)2, "采购退货所引起的出库");
		map.put((byte)3, "销售定单所引起的出库");
		map.put((byte)4, "销售退货所引起的入库");
		map.put((byte)5, "员工领用所引起的出库");
		map.put((byte)6, "报损所引起的出库");
		map.put((byte)7, "仓库调度所引起的出库");
		map.put((byte)8, "仓库调度所引起的入库");
		map.put((byte)9, "生产材料领用出库");
		map.put((byte)10, "生产成品入库");
		map.put((byte)100, "未知原因的入库");
		map.put((byte)101, "未知原因的出库");
		return map;
	}
	
	//出入库原因单据类型
	public static int STOCK_IN_OUT_SOURCE_TYPE_MAP(String map){
		if (map.equals("采购所引起的入库"))
			return 1;
		if (map.equals("采购退货所引起的出库"))
			return 2;
		if (map.equals("销售定单所引起的出库"))
			return 3;
		if (map.equals("销售退货所引起的入库"))
			return 4;
		if (map.equals("员工领用所引起的出库"))
			return 5;
		if (map.equals("报损所引起的出库"))
			return 6;
		if (map.equals("仓库调度所引起的出库"))
			return 7;
		if (map.equals("仓库调度所引起的入库"))
			return 8;
		if (map.equals("生产材料领用出库"))
			return 9;
		if (map.equals("生产成品入库"))
			return 10;
		if (map.equals("未知原因的入库"))
			return 100;
		if (map.equals("未知原因的出库"))
			return 101;
		return 0;
	}
	
	//审核状态 1为正在申请2为已审核3为已完成
	public static byte AUDIT_STATUS1=1;
	public static byte AUDIT_STATUS2=2;
	public static byte AUDIT_STATUS3=3;
	public static Map<Byte,String> AUDIT_STATUS_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "正在申请");
		map.put((byte)2, "已审核");
		map.put((byte)3, "已完成");
		return map;
	}
	//权限
	public static byte RIGHT_LIVEL1=1;
	public static byte RIGHT_LIVEL11=11;
	public static byte RIGHT_LIVEL12=12;
	public static byte RIGHT_LIVEL13=13;
	public static byte RIGHT_LIVEL14=14;
	public static byte RIGHT_LIVEL15=15;
	public static byte RIGHT_LIVEL16=16;
	public static byte RIGHT_LIVEL17=17;
	
	
	public static byte RIGHT_LIVEL2=2;
	public static byte RIGHT_LIVEL21=21;
	public static byte RIGHT_LIVEL22=22;
	public static byte RIGHT_LIVEL23=23;
	public static byte RIGHT_LIVEL24=24;
	public static byte RIGHT_LIVEL25=25;
	public static byte RIGHT_LIVEL26=26;
	public static byte RIGHT_LIVEL27=27;
	public static byte RIGHT_LIVEL28=28;
	public static byte RIGHT_LIVEL29=29;
	
	public static byte RIGHT_LIVEL3=3;
	public static byte RIGHT_LIVEL31=31;
	public static byte RIGHT_LIVEL32=32;
	public static byte RIGHT_LIVEL33=33;
	public static byte RIGHT_LIVEL34=34;
	public static byte RIGHT_LIVEL35=35;
	public static byte RIGHT_LIVEL36=36;
	
	public static byte RIGHT_LIVEL4=4;
	public static byte RIGHT_LIVEL41=41;
	public static byte RIGHT_LIVEL42=42;
	
	public static byte RIGHT_LIVEL5=5;
	public static byte RIGHT_LIVEL51=51;
	
	public static byte RIGHT_LIVEL6=6;
	public static byte RIGHT_LIVEL61=61;
	public static byte RIGHT_LIVEL62=62;
	public static byte RIGHT_LIVEL63=63;
	public static byte RIGHT_LIVEL64=64;
	public static byte RIGHT_LIVEL65=65;
	public static byte RIGHT_LIVEL66=66;
	
	public static byte RIGHT_LIVEL7=7;
	public static byte RIGHT_LIVEL71=71;
	public static byte RIGHT_LIVEL72=72;
	public static byte RIGHT_LIVEL73=73;
	public static byte RIGHT_LIVEL74=74;
	public static byte RIGHT_LIVEL75=75;
	public static byte RIGHT_LIVEL76=76;
	
	public static byte RIGHT_LIVEL8=8;
	public static byte RIGHT_LIVEL81=81;
	public static byte RIGHT_LIVEL82=82;
	public static byte RIGHT_LIVEL83=83;
	public static byte RIGHT_LIVEL84=84;
	public static byte RIGHT_LIVEL85=85;
	public static byte RIGHT_LIVEL86=86;
	public static byte RIGHT_LIVEL87=87;
	
	public static byte RIGHT_LIVEL9=9;
	public static byte RIGHT_LIVEL91=91;
	public static byte RIGHT_LIVEL92=92;
	
	public static byte RIGHT_LIVEL011=11;
	public static byte RIGHT_LIVEL0111=111;
	public static byte RIGHT_LIVEL0112=112;
	public static byte RIGHT_LIVEL0113=113;
	public static byte RIGHT_LIVEL0114=114;
	public static byte RIGHT_LIVEL0115=115;
	public static byte RIGHT_LIVEL0116=116;
	
	//public static byte RIGHT_LIVEL0136=0136;
	
	//用户管理  
//	public static byte RIGHT_LIVEL011=11;
//	public static byte RIGHT_LIVEL0111=111;
//	public static byte RIGHT_LIVEL0112=112;
//	public static byte RIGHT_LIVEL0113=113;
	//-----------营销管理--
	public static byte RIGHT_LIVEL012=12;
	public static byte RIGHT_LIVEL0121=121;
	public static byte RIGHT_LIVEL0123=123;
	public static byte RIGHT_LIVEL0124=124;
	public static byte RIGHT_LIVEL0125=125;
	public static byte RIGHT_LIVEL0126=126;
	
	public static Map<Byte, String> RIGHT_TYPE_MAP_MAIN() {
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "订单管理");
		map.put((byte)2, "会员卡管理");
		map.put((byte)3, "基础数据管理");
		map.put((byte)4, "进货管理");
		map.put((byte)6, "库存管理");
		map.put((byte)7, "报表管理");
		map.put((byte)8, "系统设置");
		map.put((byte)9, "优惠卷管理");
		map.put((byte)11, "权限管理");
		map.put((byte)12, "用户管理");
		return map;
	}
	
	public static Map<Byte,String>  RIGHT_TYPE_MAP(){
		Map<Byte,String> map=new LinkedHashMap<Byte,String>();
		map.put((byte)1, "订单管理");
		map.put((byte)11, "销售");
		map.put((byte)12, "在线订单");
		map.put((byte)13, "在线预订单");
		map.put((byte)14, "订单评论");
		map.put((byte)15, "销售退货单");
		map.put((byte)16, "订单处理");
		map.put((byte)17, "退款单处理");
		
		map.put((byte)2, "会员卡管理");
		map.put((byte)21, "发卡");
		map.put((byte)22, "补卡");
		map.put((byte)23, "会员卡查询");
		map.put((byte)24, "会员卡充值");
		map.put((byte)25, "领取礼包");
		map.put((byte)26, "级别管理");
		map.put((byte)27, "礼品管理");
		map.put((byte)28, "交班");
		map.put((byte)29, "交班记录");
		
		map.put((byte)3, "基础数据管理");
		map.put((byte)31, "商品管理");
		map.put((byte)32, "员工管理");
		map.put((byte)33, "仓库管理");
		map.put((byte)34, "供应商管理");
		map.put((byte)35, "商店管理");
		map.put((byte)36, "商柜管理");
		
		map.put((byte)4, "进货管理");
		map.put((byte)41, "进货");
		map.put((byte)42, "退货");
		
		
		map.put((byte)6, "库存管理");
		map.put((byte)61, "仓库调拨");
		map.put((byte)62, "商品报损");
		map.put((byte)63, "物品领用");
		map.put((byte)64, "其他方式出库存单");
		map.put((byte)65, "库存报警");
		map.put((byte)66, "出入库存单查询");
		
		map.put((byte)7, "报表管理");
		map.put((byte)71, "采购报表");
		map.put((byte)72, "库存报表");
		map.put((byte)73, "销售报表");
		map.put((byte)74, "资金报表");
		map.put((byte)75, "利润报表");
		map.put((byte)76, "所有员工交班记录");
		
		map.put((byte)8, "系统设置");
		map.put((byte)81, "操作日记管理");
		map.put((byte)82, "角色权限管理");
		map.put((byte)83, "系统配置设置");
		map.put((byte)84, "条码生成管理");
		map.put((byte)85, "数据库备份还原");
		map.put((byte)86, "交班");
		map.put((byte)87, "交班记录");
		
		map.put((byte)9, "优惠卷管理");
		map.put((byte)91, "查询优惠卷");
		map.put((byte)92, "添加优惠卷");
		
		map.put((byte)11, "权限管理");
		map.put((byte)111, "权限管理");
		map.put((byte)112, "充值规则");
		map.put((byte)113, "会员卡查询");
		map.put((byte)114, "新闻管理");
		map.put((byte)115, "轮牌管理");
		
		//用户管理 -------------------------------------------------------
//		map.put((byte)11, "用户管理");
//		map.put((byte)111, "增加用户管理");
//		map.put((byte)112, "删除用户管理");
//		map.put((byte)113, "浏览用户管理");
		
		//------营销管理------
		map.put((byte)12, "用户管理");
		map.put((byte)121, "满就送");
		map.put((byte)122, "优惠卷");
		map.put((byte)123, "自定义优惠");
		map.put((byte)124, "营销评估");
		map.put((byte)126, "招聘管理");
		map.put((byte)125, "优惠卷管理");
		return map;
	}
	
	public static int RIGHT_NUM(byte b) {
		switch (b) {
		case 11: return 0;
		case 12: return 1;
		case 13: return 2;
		case 14: return 3;
		case 15: return 4;
		
		case 21: return 5;
		case 22: return 6;
		case 23: return 7;
		case 24: return 8;
		
		case 31: return 9;
		case 32: return 10;
		case 33: return 11;
		case 34: return 12;
		case 35: return 13;
		
		case 41: return 14;
		case 42: return 15;
		
		case 61: return 16;
		case 62: return 17;
		case 63: return 18;
		case 64: return 19;
		case 65: return 20;
		case 66: return 21;
		
		case 71: return 22;
		case 72: return 23;
		case 73: return 24;
		case 74: return 25;
		case 75: return 26;
		
		case 81: return 27;
		case 82: return 28;
		case 83: return 29;
		case 84: return 30;
		case 85: return 31;
		}
		return -1;
	}
	
	public static CommodityExeAttrs getCommodityExeAttrs() {
		CommodityExeAttrs ceas = new CommodityExeAttrs();
        CommodityExeAttr cea = new CommodityExeAttr("spicy", "辣味", CommodityExeAttr.EXE_ATTR_TYPE_SINGLE_CHOOSE);
        cea.addOption(new CommodityExeAttrOption("spicy0", "加辣"));
        cea.addOption(new CommodityExeAttrOption("spicy1", "微辣"));
        cea.addOption(new CommodityExeAttrOption("spicy2", "不辣"));
        ceas.addAttr(cea);
        cea = new CommodityExeAttr("Garlic", "蒜味", CommodityExeAttr.EXE_ATTR_TYPE_SINGLE_CHOOSE);
        cea.addOption(new CommodityExeAttrOption("spicy0", "正常"));
        cea.addOption(new CommodityExeAttrOption("spicy1", "多蒜"));
        ceas.addAttr(cea);
		return ceas;
	};
	public static String[] INFO_SALES = new String[]{"进货销售", "仅进货", "仅销售"};
	
	/**
	 * 添加明细，添加出入库单、明细，添加库存，添加资金
	 * 
	 * modelList:表格数据
	 * tStore:仓库
	 * stockInOutSourceType出入库原因类型：//1为采购所引起的入库，原因单为采购单编号 2为采购退货所引起的出库，原因单为退货单
							//3为销售定单所引起的出库，原因单为销售定单 4为销售退货所引起的入库，原因单为销售退货单
							//5为员工领用所引起的出库，原因单为领用单 6为报损所引起的出库，原因单为报损单 
							//7为仓库调度所引起的出库，原因单为仓库调拨单 8为仓库调度所引起的入库，原因单为仓库调拨单 
							//9为生产材料领用出库 10为生产成品入库 100为未知原因的入库 101为未知原因的出库
		stockInOutType：入/出类型TINYINT 1为入库单 2为出库单
		sourceID:原因单据编号
		moneyInOutType:资金出入类型 //出入类型1为收款 2为出款
		moneyInOutsourceType:资金出入原因类型 1为采购引起的出款 2为采购退货引起收款3为销售引起的收款 4为销售退货引起的出款 5为充值收款 10为费用单 
		personID://出款人/收款人CHAR(15)
	 * */
	public static void main(String[] args) {
		double d1 = 3.23456;  
		double d2 = 2.0;  
		  
		double d3 = Math.round((d1 + d2) * 100) / 100.0;  
		System.out.println(d3);
	}
	public static void addInOutBillDetailMoney(List<TBillDetail> modelList,TStore tStore,byte stockInOutSourceType,byte  stockInOutType,String sourceID,byte moneyInOutType,byte moneyInOutsourceType,String personID){
		//单据明细
		TBillDetailService tBillDetailService=BuildSpringApplication.getInstance().getTBillDetailServiceImpl();
		//单据明细说明
		TBillDetailDesService tBillDetailDesService=BuildSpringApplication.getInstance().getTBillDetailDesServiceImpl();
		//出入库
		TStockInOutService tStockInOutService=BuildSpringApplication.getInstance().getTStockInOutServiceImpl();
		//出入库明细
		TStockInOutDetailService tStockInOutDetailService=BuildSpringApplication.getInstance().getTStockInOutDetailServiceImpl();
		//库存
		TStockService tStockService=BuildSpringApplication.getInstance().getTStockServiceImpl();
//		//资金出入
//		TMoneyInOutService tMoneyInOutService=BuildSpringApplication.getInstance().getTMoneyInOutServiceImpl();
		//判断是否表格是否存在商品信息
		if(modelList==null||modelList.size()==0){
			JOptionPane.showMessageDialog(null, "请先添加商品");
			return;
		}
		//添加出入库存单
		TStockInOut tStockInOut = new TStockInOut();
		tStockInOut.setInOutID(UUID.GenUUID15());
		tStockInOut.setType(stockInOutType);
		tStockInOut.setSourceType(stockInOutSourceType);
		tStockInOut.setTStore(tStore);
		tStockInOut.setSource(sourceID);
		tStockInOut.setOperator(ApplicationContext.OPERATOR_ID);
		tStockInOut.setHappenTime(new Date());
		try {
			tStockInOutService.saveService(tStockInOut);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		//修改库存量/商品数量
		TStock tStock = new TStock();
		tStock.setTStore(tStore);//仓库
		for(int i = 0; i < modelList.size(); ++i) {//商品
			TBillDetail billDetail=modelList.get(i);
			tStock.setTCommodity(new TCommodity(billDetail.getCommodityID()));//商品
			try {
				List<TStock> tStockList = tStockService.findService(tStock);//查询库存中是否已经存在同一仓库的同一商品
				//出库
				if(stockInOutType==STOCK_TYPE_OUT){
					if (tStockList != null && tStockList.size() != 0) {//商品数量相减
						tStockList.get(0).setNum(tStockList.get(0).getNum()-modelList.get(i).getNum());
						tStockService.saveOrUpdateService(tStockList.get(0));
					}
				}else{
					//入库
					if (tStockList == null || tStockList.size() == 0) {//不存在添加
						tStock.setStockID(UUID.GenUUID15());
						tStock.setNum(billDetail.getNum());
//						tStock.setAvgPrice(billDetail.getPrice());//首次添加 价格等于进货价
						tStockService.saveService(tStock);
					} else {//已存在商品数量相加
						TStock stock=tStockList.get(0);
//						stock.setAvgPrice(Math.round(((stock.getNum()*stock.getAvgPrice()+billDetail.getNum()*billDetail.getPrice())/(stock.getNum()+billDetail.getNum()))*100)/100);
						stock.setNum(stock.getNum()+billDetail.getNum());
						tStockService.saveOrUpdateService(stock);
					}
				}
				
//				//添加单据和出入库单明细
//				if(tStockList != null && tStockList.size() != 0){
//					billDetail.setAvgPrice(tStockList.get(0).getAvgPrice());
//				}else{
//					billDetail.setAvgPrice(0.00);
//				}
				tBillDetailService.saveOrUpdateService(billDetail);
				Set<TBillDetailDes> set=billDetail.getTBillDetailDes();
				if(set!=null&&set.size()!=0){
					Iterator<TBillDetailDes> it=set.iterator();
					while(it.hasNext()){
						TBillDetailDes dec=it.next();
						tBillDetailDesService.saveService(dec);
					}
				}
				TStockInOutDetail detall=new TStockInOutDetail();
				detall.setNum(billDetail.getNum());//商品数据INTEGER
				detall.setTStockInOut(tStockInOut);//入/出库单
				detall.setTCommodity(new TCommodity(billDetail.getCommodityID()));//商品
				tStockInOutDetailService.saveService(detall);
				
				
				
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		}
		//添加资金出入表
		addMondyInOut(moneyInOutType, personID, moneyInOutsourceType, sourceID);
	}
	
	/**计算库存量*/
	public static int stockTotalNum(String CommodityID, String StoreID){
		int totalNum=0;
		
		TStockService tStockService = BuildSpringApplication.getInstance().getTStockServiceImpl();
		TStock tStock = new TStock();
		tStock.setTCommodity(new TCommodity(CommodityID));
		tStock.setTStore(new TStore(StoreID));
		try {
			List<TStock> tStockList = tStockService.findListService(tStock);
			if(tStockList!=null&&tStockList.size()!=0){
				for(int i=0;i<tStockList.size();i++){
					TStock stock=tStockList.get(i);
					totalNum=totalNum+stock.getNum();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return totalNum;
	}
	
	public static void addMondyInOut(byte type, String personID, byte sourceType, String sourceID) {
		//添加资金出入表
		TMoneyInOutService tMoneyInOutService=BuildSpringApplication.getInstance().getTMoneyInOutServiceImpl();
		
		TMoneyInOut tMoneyInOut = new TMoneyInOut();
		tMoneyInOut.setInOutID(UUID.GenUUID15());//资金出入编号CHAR(15) PK
		tMoneyInOut.setType(type);//出入类型1为收款 2为出款
		tMoneyInOut.setPersonID(personID);//出款人/收款人CHAR(15)
		tMoneyInOut.setSourceType(sourceType);//出入原因类型TINYINT  1为采购引起的出款 2为采购退货引起收款3为销售引起的收款 4为销售退货引起的出款 5为充值收款 10为费用单 
		tMoneyInOut.setSource(sourceID);//原因单据编号CHAR(15)
		tMoneyInOut.setIsDone(true);//是否已经完成
		tMoneyInOut.setOperator(ApplicationContext.OPERATOR_ID);//经手人CHAR(15)
		tMoneyInOut.setHappenTime(new Date());//操作时间DATETIME
		tMoneyInOut.setCheckTime(new Date());//审核时间DATETIME
		try {
			tMoneyInOutService.saveService(tMoneyInOut);
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
	//判断表格数据
	public static boolean ifBillDetail(List<TBillDetail> modelList, String StoreID){
		boolean okNull = false;//记录是否允许价格为空，放置消息框无限弹出
		for (int i = 0; i < modelList.size(); ++i) {
			TBillDetail tBillDetail = modelList.get(i);
			if (tBillDetail.getCommodityID() == null || tBillDetail.getCommodityID().length() == 0) {
				JOptionPane.showMessageDialog(null, "存在商品编号为空的商品！");
				return false;
			}
			if (tBillDetail.getNum() == 0) {
				JOptionPane.showMessageDialog(null, "存在商品数量为0的商品！");
				return false;
			} 
			if (tBillDetail.getPrice() <= 0 && !okNull) {
				if(Util.showConfirmDialog("允许商品的价格不大于零？")!=0) {
					return false;
				} else {
					okNull = true;
				}
			}
			
			if (StoreID != null && !StoreID.equals("")) {
				
				int num = ApplicationContext.stockTotalNum(tBillDetail.getCommodityID(), StoreID);
				if (num - tBillDetail.getNum() < 0) {
					JOptionPane.showMessageDialog(null, "第" + (i+1) + "件商品，在当前仓库库存量不足，请正确填写数量！");
					return false;
				}
			}
		}
		return true;
	}
	
	//计算表格合计和库存量
	public static void countStoreNumber(List<TBillDetail> modelList,TStore tStore,String commodityID,JTextField numTF,JTextField moneyTF,JTextField storageQuantityTF) {
		//库存
		if(modelList!=null&&modelList.size()!=0){
			numTF.setText("0");
			moneyTF.setText("0.0");
			storageQuantityTF.setText("0");
			int num=0;
			double totalPrcie=0.0;
			for (int i = 0; i < modelList.size(); ++i) {
				TBillDetail billDetail=modelList.get(i);
				num=num+billDetail.getNum();
				totalPrcie=totalPrcie+(billDetail.getPrice()*billDetail.getNum());
			}
			numTF.setText(num+"");
			moneyTF.setText(totalPrcie+"");
			//当前库存量
			if(tStore!=null&&commodityID!=null&&!commodityID.equals("")){
				storageQuantityTF.setText(stockTotalNum(commodityID, tStore.getStoreID())+"");
			}
		}
	}
	
	//加权价格DECIMAL(20,3)加权价=（库存数量*加权价+采购价*采购数量）/（库存数量+采购数量）
	public static void TCommodityAvgPrice(final List<TBillDetail> tBillDetailList) {
		System.out.println(tBillDetailList.size());
		new Thread() {
			private TCommodityService tCommodityService = BuildSpringApplication.getInstance().getTCommodityServiceImpl();
			@Override
			public void run() {
				for (int i = tBillDetailList.size()-1; i >= 0; --i) {
					TBillDetail tBillDetail = tBillDetailList.get(i);
					TCommodity tCommodity = tBillDetail.getCommodity();
					if (tCommodity != null) {
						try {
							tCommodity = tCommodityService.getByIdService(tCommodity.getCommodityID());
							//库存量
							int stockNum = stockTotalNum(tCommodity.getCommodityID(), null);
							double avgPrice = (stockNum*tCommodity.getAvgPrice()+tBillDetail.getPrice()*tBillDetail.getNum())/(stockNum+tBillDetail.getNum());
							tCommodity.setAvgPrice(Util.DoubleHowMany(2, avgPrice));
							tCommodityService.modifyService(tCommodity);
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				}
			}
		}.start();
	}
	//加权价 （仓库1（数量*价格）+仓库2（数量*价格））/所有商品库存数量
//	public static double WeightingPrice(TCommodity tCommodity) {
//		TStockService tStockService = BuildSpringApplication.getInstance().getTStockServiceImpl();
//		TStock tStock = new TStock();
//		tStock.setTCommodity(tCommodity);
//		List<TStock> tStockList = null;
//		try {
//			int num = 0;//存储库存数量
//			double totlePrice = 0;//总额
//			tStockList = tStockService.findService(tStock);
//			for (int i = tStockList.size() - 1; i >= 0; --i) {
//				TStock stock=tStockList.get(i);
//				num += stock.getNum();
//				totlePrice += stock.getNum() * stock.getAvgPrice();
//			}
//			return (int)(totlePrice/num*100)/100;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		return 0;
//	}
	
//	加权价=（库存数量*加权价+采购价*采购量）/（库存数量+采购数量）
//	public static double getWeightingPrice(String tCommodityId){
//		TStockService tStockService = BuildSpringApplication.getInstance().getTStockServiceImpl();
//		TStock tStock = new TStock();
//		tStock.setTCommodity(new TCommodity(tCommodityId));
//		List<TStock> tStockList = null;
//		try {
//			int num = 0;//存储库存数量
//			tStockList = tStockService.findService(tStock);
//			for (int i = tStockList.size() - 1; i >= 0; --i) {
//				num += tStockList.get(i).getNum();
//			}
//			double WeightingPrice = 0;
//			return WeightingPrice;
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		return 0;
//	}
	
	//储存会员卡号的组件
	public static JTextField tf = null;

	public static void Focus() {
		//令焦点处于会员卡号上
		if (tf != null) {
			tf.requestFocus();
		}
	}
}
